home *** CD-ROM | disk | FTP | other *** search
/ Workbench Design / WB Collection.iso / workbench werkzeuge / bildschirmschoner / bserver_v1.5 / sources.lha / Sources / lib / libsources / bitmap_chunky.s next >
Text File  |  1994-11-17  |  7KB  |  386 lines
  1.     include    "graphics/gfx.i"
  2.     include "exec/memory.i"
  3.  
  4.     section text,code
  5.  
  6. *    Routine per la conversione ChunkyToPlanar per bitmaps fino a 8
  7. *    bitplanes e NON interleaved, per MC68000 e MC68020
  8. *    Copyright © 1994 by Stefano Reksten
  9.  
  10. _LVOAllocMem    EQU    -198
  11. _LVOFreeMem        EQU    -210
  12.  
  13. *    d0: colore
  14. *    d1: coord x
  15. *    d2: coord y
  16. *    a2: *bitmap
  17. *    a3: *table
  18.  
  19.     xdef    _ChunkyToPlanar
  20.  
  21. _ChunkyToPlanar:
  22.  
  23. * salviamo d3 e d4 che useremo nella funzione.
  24.     movem.l    d0-d5,-(sp)
  25.  
  26. * come prima cosa trasformiamo le coordinate x-y in:
  27. * bytes dall'inizio (d2), posizione bit (d1) (d3 scratch)
  28.     and.l    #$FFFF,d2
  29.     asl    #2,d2
  30.     move.l    (a3,d2),d2
  31.     and.l    #$FFFF,d1
  32.     move.b    d1,d3
  33.     asr    #3,d1
  34.     add.w    d1,d2
  35.     moveq    #7,d1
  36.     and.b    #%00000111,d3
  37.     sub.b    d3,d1
  38.  
  39.     move.b    #8,d4
  40.     sub.b    bm_Depth(a2),d4
  41.     rol.b    d4,d0
  42.  
  43.     move.b    #$FF,d3
  44.     bclr    d1,d3
  45.  
  46.     lea    bm_Planes(a2),a0
  47.     lea    .DispatchTable,a1
  48.     moveq    #0,d5
  49.     move.b    bm_Depth(a2),d5
  50.     lsl    #2,d5
  51.     move.l    0(a1,d5.w),a1
  52.     jmp    (a1)
  53.  
  54. .DispatchTable:
  55.     dc.l    .NoPlanes,.Pl0,.Pl1,.Pl2,.Pl3,.Pl4,.Pl5,.Pl6,.Pl7
  56.  
  57. .Pl7:
  58.     rol.b    #1,d0
  59.     move.b    d0,d4
  60.     and    #%00000001,d4
  61.     asl    d1,d4
  62.     movea.l    28(a0),a1
  63.     adda.l    d2,a1
  64.     and.b    d3,(a1)
  65.     or.b    d4,(a1)
  66.  
  67. .Pl6:
  68.     rol.b    #1,d0
  69.     move.b    d0,d4
  70.     and    #%00000001,d4
  71.     asl    d1,d4
  72.     movea.l    24(a0),a1
  73.     adda.l    d2,a1
  74.     and.b    d3,(a1)
  75.     or.b    d4,(a1)
  76.  
  77. .Pl5:
  78.     rol.b    #1,d0
  79.     move.b    d0,d4
  80.     and    #%00000001,d4
  81.     asl    d1,d4
  82.     movea.l    20(a0),a1
  83.     adda.l    d2,a1
  84.     and.b    d3,(a1)
  85.     or.b    d4,(a1)
  86.  
  87. .Pl4:
  88.     rol.b    #1,d0
  89.     move.b    d0,d4
  90.     and    #%00000001,d4
  91.     asl    d1,d4
  92.     movea.l    16(a0),a1
  93.     adda.l    d2,a1
  94.     and.b    d3,(a1)
  95.     or.b    d4,(a1)
  96.  
  97. .Pl3:
  98.     rol.b    #1,d0
  99.     move.b    d0,d4
  100.     and    #%00000001,d4
  101.     asl    d1,d4
  102.     movea.l    12(a0),a1
  103.     adda.l    d2,a1
  104.     and.b    d3,(a1)
  105.     or.b    d4,(a1)
  106.  
  107. .Pl2:
  108.     rol.b    #1,d0
  109.     move.b    d0,d4
  110.     and    #%00000001,d4
  111.     asl    d1,d4
  112.     movea.l    8(a0),a1
  113.     adda.l    d2,a1
  114.     and.b    d3,(a1)
  115.     or.b    d4,(a1)
  116.  
  117. .Pl1:
  118.     rol.b    #1,d0
  119.     move.b    d0,d4
  120.     and    #%00000001,d4
  121.     asl    d1,d4
  122.     movea.l    4(a0),a1
  123.     adda.l    d2,a1
  124.     and.b    d3,(a1)
  125.     or.b    d4,(a1)
  126.  
  127. .Pl0:
  128.     rol.b    #1,d0
  129.     move.b    d0,d4
  130.     and    #%00000001,d4
  131.     asl    d1,d4
  132.     movea.l    (a0),a1
  133.     adda.l    d2,a1
  134.     and.b    d3,(a1)
  135.     or.b    d4,(a1)
  136.  
  137. .NoPlanes:
  138. * fine, recuperiamo i registri e torniamo.
  139.     movem.l    (sp)+,d0-d5
  140.     rts
  141.  
  142.     xdef    _ChunkyToPlanar68020
  143.  
  144. _ChunkyToPlanar68020:
  145.  
  146. * salviamo d3 e d4 che useremo nella funzione.
  147.     movem.l    d0-d5,-(sp)
  148.  
  149. * come prima cosa trasformiamo le coordinate x-y in:
  150. * bytes dall'inizio (d2), posizione bit (d1) (d3 scratch)
  151.     move.l    (a3,d2*4),d2
  152.  
  153.     move.b    d1,d3
  154.     asr    #3,d1
  155.     add.l    d1,d2
  156.     move.b    d3,d1
  157.     and.b    #%00000111,d1
  158.  
  159.     move.b    #8,d4
  160.     sub.b    bm_Depth(a2),d4
  161.     rol.b    d4,d0
  162.  
  163.     move.b    #$FF,d3
  164.     bclr    d1,d3
  165.  
  166. * mettiamo l'indirizzo dell'array dei PLANEPTR in a0
  167.     lea    bm_Planes(a2),a0
  168.     
  169.     lea    .DispatchTable_020,a1
  170.     moveq    #0,d5
  171.     move.b    bm_Depth(a2),d5
  172.     move.l    0(a1,d5.w*4),a1
  173.     jmp    (a1)
  174.  
  175. .DispatchTable_020:
  176.     dc.l    .NoPlanes_020,.Pl0_020,.Pl1_020,.Pl2_020,.Pl3_020,.Pl4_020,.Pl5_020,.Pl6_020,.Pl7_020
  177.  
  178. .Pl7_020:
  179.     rol.b    #1,d0
  180.     bfins    d0,([28,a0],d2.l),{d1:1}
  181.  
  182. .Pl6_020:
  183.     rol.b    #1,d0
  184.     bfins    d0,([24,a0],d2.l),{d1:1}
  185.  
  186. .Pl5_020:
  187.     rol.b    #1,d0
  188.     bfins    d0,([20,a0],d2.l),{d1:1}
  189.  
  190. .Pl4_020:
  191.     rol.b    #1,d0
  192.     bfins    d0,([16,a0],d2.l),{d1:1}
  193.  
  194. .Pl3_020:
  195.     rol.b    #1,d0
  196.     bfins    d0,([12,a0],d2.l),{d1:1}
  197.  
  198. .Pl2_020:
  199.     rol.b    #1,d0
  200.     bfins    d0,([8,a0],d2.l),{d1:1}
  201.  
  202. .Pl1_020:
  203.     rol.b    #1,d0
  204.     bfins    d0,([4,a0],d2.l),{d1:1}
  205.  
  206. .Pl0_020:
  207.     rol.b    #1,d0
  208.     bfins    d0,([0,a0],d2.l),{d1:1}
  209.  
  210. .NoPlanes_020:
  211. * fine, recuperiamo i registri e torniamo.
  212.     movem.l    (sp)+,d0-d5
  213.     rts
  214.  
  215.  
  216. *    Funzioni per creare e rilasciare la tabella di offset che serve
  217. *    per sveltire le ChunkyToPlanar.
  218.  
  219.     xdef    _CreateCTPTable
  220.     xdef    _FreeCTPTable
  221.  
  222. *    a2: *bitmap
  223.  
  224. _CreateCTPTable:
  225.     movem.l    d2-d3/a6,-(sp)
  226.     moveq    #0,d0
  227.     move.w    bm_Rows(a2),d0
  228.     asl    #2,d0            ; prepara d0 e
  229.     moveq    #0,d1            ; d1 per AllocMem
  230.     move.l    $4,a6
  231.     jsr    _LVOAllocMem(a6)
  232.     tst    d0
  233.     beq    .notable
  234.     move.l    d0,d3            ; salva d0 (d3 scratch)
  235.     move.l    d0,a0            ; a0 = &table
  236.     moveq    #0,d0
  237.     move.w    bm_Rows(a2),d0
  238.     subq    #1,d0            ; prepara d0 per il ciclo
  239.     moveq    #0,d1
  240.     moveq    #0,d2
  241.     move.w    bm_BytesPerRow(a2),d2
  242. .crtloop
  243.     move.l    d1,(a0)+
  244.     add.l    d2,d1
  245.     dbra    d0,.crtloop
  246.     move.l    d3,d0            ; ripristina d0
  247. .notable
  248.     movem.l    (sp)+,d2-d3/a6
  249.     rts
  250.  
  251. *    a1: *table
  252. *    a2: *bitmap
  253.  
  254. _FreeCTPTable:
  255.     move.l    a6,-(sp)
  256.     moveq    #0,d0
  257.     move.w    bm_Rows(a2),d0
  258.     asl    #2,d0
  259.     move.l    $4,a6
  260.     jsr    _LVOFreeMem(a6)
  261.     move.l    (sp)+,a6
  262.     rts
  263.  
  264.  
  265.  
  266. *    ChunkyToPlanarArray (solo per 68020 per ora)
  267.  
  268. *    d1: coord x
  269. *    d2: coord y
  270. *    d3: larghezza array
  271. *    d4: altezza array
  272. *    d5: bytesperrow dell'array
  273. *    a2: *bitmap            solo lettura
  274. *    a3: *table            solo lettura
  275. *    a4: array di colori        modifica
  276.  
  277.     xdef    _ChunkyToPlanarArray68020
  278.  
  279. _ChunkyToPlanarArray68020:
  280.  
  281. * salviamo i registri che useremo nella funzione.
  282.     movem.l    d0-d7/a4-a6,-(sp)
  283.     moveq    #0,d0
  284.  
  285. * come prima cosa trasformiamo le coordinate x-y in:
  286. * bytes dall'inizio (d2), posizione bit (d1) (d6 scratch)
  287.     move.l    (a3,d2*4),d2
  288.     move.b    d1,d6
  289.     asr    #3,d1
  290.     add.l    d1,d2
  291.     move.b    d6,d1
  292.     and.b    #%00000111,d1
  293.  
  294. * mettiamo l'indirizzo dell'array dei PLANEPTR in a0
  295.     lea    bm_Planes(a2),a0
  296.  
  297. * facciamo 2 cicli: quello della larghezza interno, quello dell'altezza
  298. * esterno. Per i contatori usiamo (ma guarda un po') proprio d3, d4
  299.     and.l    #$0000FFFF,d5
  300.     sub    d3,d5        ; d5 = numero di colori per riga da saltare
  301.     subq    #1,d3
  302.     subq    #1,d4
  303.  
  304.     move.w    d3,d7        ; memorizziamo la larghezza dell'array
  305.                 ; da disegnare ( != larghezza totale )
  306.  
  307.     lea    .DispatchTableA_020,a1
  308.     moveq    #0,d6
  309.     move.b    bm_Depth(a2),d6
  310.     move.l    0(a1,d6.w*4),a1    ; a1 = indirizzo della routine
  311.                     ; di disegno
  312.  
  313.     move.b    #8,d6
  314.     sub.b    bm_Depth(a2),d6        ; numero di rol da fare sul colore
  315.                     ; anche se d6 era scratch non viene
  316.                      ; piu' usato.
  317.  
  318. .RowsCycle_020:
  319.     move.l    d2,a5        ; memorizziamo la posiz byte
  320.     move.l    d1,a6        ; e la posiz bit iniziale
  321.  
  322. .ColsCycle_020:
  323.     move.b    (a4)+,d0    ; d0 = colore corrente
  324.     rol.b    d6,d0
  325.  
  326.     jmp    (a1)        ; disegna il colore
  327.  
  328. .Pl7A_020:
  329.     rol.b    #1,d0
  330.     bfins    d0,([28,a0],d2.l),{d1:1}
  331.  
  332. .Pl6A_020:
  333.     rol.b    #1,d0
  334.     bfins    d0,([24,a0],d2.l),{d1:1}
  335.  
  336. .Pl5A_020:
  337.     rol.b    #1,d0
  338.     bfins    d0,([20,a0],d2.l),{d1:1}
  339.  
  340. .Pl4A_020:
  341.     rol.b    #1,d0
  342.     bfins    d0,([16,a0],d2.l),{d1:1}
  343.  
  344. .Pl3A_020:
  345.     rol.b    #1,d0
  346.     bfins    d0,([12,a0],d2.l),{d1:1}
  347.  
  348. .Pl2A_020:
  349.     rol.b    #1,d0
  350.     bfins    d0,([8,a0],d2.l),{d1:1}
  351.  
  352. .Pl1A_020:
  353.     rol.b    #1,d0
  354.     bfins    d0,([4,a0],d2.l),{d1:1}
  355.  
  356. .Pl0A_020:
  357.     rol.b    #1,d0
  358.     bfins    d0,([0,a0],d2.l),{d1:1}
  359.  
  360. .NoPlanesA_020:
  361.  
  362. * fine, recuperiamo i registri e torniamo.
  363.     addq    #1,d1        ; nuova coordinata x in posizione del bit
  364.     and.b    #%00000111,d1
  365.     bne.b    .GoOn_020
  366.     addq    #1,d2
  367. .GoOn_020
  368.     dbra.w    d3,.ColsCycle_020
  369.  
  370.     move.w    d7,d3            ; recupero contatore del ciclo
  371.     adda.l    d5,a4            ; skip dei colori
  372.     move.l    a5,d2            ; recupero bits dall'inizio
  373.     move.l    a6,d1            ; recupero bytes dall'inizio
  374.     add.w    bm_BytesPerRow(a2),d2     ; prossima riga
  375.  
  376.     dbra.w    d4,.RowsCycle_020
  377.  
  378.     movem.l    (sp)+,d0-d7/a4-a6
  379.     rts
  380.  
  381. .DispatchTableA_020
  382.     dc.l    .NoPlanesA_020,.Pl0A_020,.Pl1A_020,.Pl2A_020
  383.     dc.l    .Pl3A_020,.Pl4A_020,.Pl5A_020,.Pl6A_020,.Pl7A_020
  384.  
  385.     end
  386.